home *** CD-ROM | disk | FTP | other *** search
/ X User Tools / X User Tools (O'Reilly and Associates)(1994).ISO / sources / xev / xev.c < prev    next >
C/C++ Source or Header  |  1994-09-27  |  26KB  |  952 lines
  1. /*
  2.  * xev - event diagnostics
  3.  *
  4.  * $XConsortium: xev.c,v 1.14 91/05/04 23:15:11 keith Exp $
  5.  *
  6.  * Copyright 1988 Massachusetts Institute of Technology
  7.  *
  8.  * Permission to use, copy, modify, and distribute this software and its
  9.  * documentation for any purpose and without fee is hereby granted, provided
  10.  * that the above copyright notice appear in all copies and that both that
  11.  * copyright notice and this permission notice appear in supporting
  12.  * documentation, and that the name of M.I.T. not be used in advertising or
  13.  * publicity pertaining to distribution of the software without specific,
  14.  * written prior permission.  M.I.T. makes no representations about the
  15.  * suitability of this software for any purpose.  It is provided "as is"
  16.  * without express or implied warranty.
  17.  *
  18.  * Author:  Jim Fulton, MIT X Consortium
  19.  */
  20.  
  21. #include <stdio.h>
  22. #include <X11/Xos.h>
  23. #include <X11/Xlib.h>
  24. #include <X11/Xutil.h>
  25. #include <X11/Xproto.h>
  26. #include <ctype.h>
  27.  
  28. #define INNER_WINDOW_WIDTH 50
  29. #define INNER_WINDOW_HEIGHT 50
  30. #define INNER_WINDOW_BORDER 4
  31. #define INNER_WINDOW_X 10
  32. #define INNER_WINDOW_Y 10
  33. #define OUTER_WINDOW_MIN_WIDTH (INNER_WINDOW_WIDTH + \
  34.                 2 * (INNER_WINDOW_BORDER + INNER_WINDOW_X))
  35. #define OUTER_WINDOW_MIN_HEIGHT (INNER_WINDOW_HEIGHT + \
  36.                 2 * (INNER_WINDOW_BORDER + INNER_WINDOW_Y))
  37. #define OUTER_WINDOW_DEF_WIDTH (OUTER_WINDOW_MIN_WIDTH + 100)
  38. #define OUTER_WINDOW_DEF_HEIGHT (OUTER_WINDOW_MIN_HEIGHT + 100)
  39. #define OUTER_WINDOW_DEF_X 100
  40. #define OUTER_WINDOW_DEF_Y 100
  41.                 
  42.  
  43. typedef unsigned long Pixel;
  44.  
  45. char *Yes = "YES";
  46. char *No = "NO";
  47. char *Unknown = "unknown";
  48.  
  49. char *ProgramName;
  50. Display *dpy;
  51. int screen;
  52.  
  53. usage ()
  54. {
  55.     static char *msg[] = {
  56. "    -display displayname                X server to contact",
  57. "    -geometry geom                      size and location of window",
  58. "    -bw pixels                          border width in pixels",
  59. "    -bs {NotUseful,WhenMapped,Always}   backingstore attribute",
  60. "    -id windowid                        use existing window",
  61. "    -s                                  set save-unders attribute",
  62. "    -name string                        window name",
  63. "    -rv                                 reverse video",
  64. "",
  65. NULL};
  66.     char **cpp;
  67.  
  68.     fprintf (stderr, "usage:  %s [-options ...]\n", ProgramName);
  69.     fprintf (stderr, "where options include:\n");
  70.  
  71.     for (cpp = msg; *cpp; cpp++) {
  72.     fprintf (stderr, "%s\n", *cpp);
  73.     }
  74.  
  75.     exit (1);
  76. }
  77.  
  78. static int parse_backing_store (s)
  79.     char *s;
  80. {
  81.     int len = strlen (s);
  82.     char *cp;
  83.  
  84.     for (cp = s; *cp; cp++) {
  85.     if (isascii (*cp) && isupper (*cp)) *cp = tolower (*cp);
  86.     }
  87.  
  88.     if (strncmp (s, "notuseful", len) == 0) return (NotUseful);
  89.     if (strncmp (s, "whenmapped", len) == 0) return (WhenMapped);
  90.     if (strncmp (s, "always", len) == 0) return (Always);
  91.  
  92.     usage ();
  93. }
  94.  
  95. main (argc, argv)
  96.     int argc;
  97.     char **argv;
  98. {
  99.     char *displayname = NULL;
  100.     char *geom = NULL;
  101.     int i;
  102.     XSizeHints hints;
  103.     int borderwidth = 2;
  104.     Window w, subw;
  105.     XSetWindowAttributes attr;
  106.     XWindowAttributes wattr;
  107.     unsigned long mask = 0L;
  108.     int done;
  109.     char *name = "Event Tester";
  110.     Bool reverse = False;
  111.     unsigned long back, fore;
  112.  
  113.     w = 0;
  114.     ProgramName = argv[0];
  115.     for (i = 1; i < argc; i++) {
  116.     char *arg = argv[i];
  117.  
  118.     if (arg[0] == '-') {
  119.         switch (arg[1]) {
  120.           case 'd':            /* -display host:dpy */
  121.         if (++i >= argc) usage ();
  122.         displayname = argv[i];
  123.         continue;
  124.           case 'g':            /* -geometry geom */
  125.         if (++i >= argc) usage ();
  126.         geom = argv[i];
  127.         continue;
  128.           case 'b':
  129.         switch (arg[2]) {
  130.           case 'w':        /* -bw pixels */
  131.             if (++i >= argc) usage ();
  132.             borderwidth = atoi (argv[i]);
  133.             continue;
  134.           case 's':        /* -bs type */
  135.             if (++i >= argc) usage ();
  136.             attr.backing_store = parse_backing_store (argv[i]);
  137.             mask |= CWBackingStore;
  138.             continue;
  139.           default:
  140.             usage ();
  141.         }
  142.           case 'i':            /* -id */
  143.         if (++i >= argc) usage ();
  144.         sscanf(argv[i], "0x%lx", &w);
  145.         if (!w)
  146.             sscanf(argv[i], "%ld", &w);
  147.         if (!w)
  148.             usage ();
  149.         continue;
  150.           case 'n':            /* -name */
  151.         if (++i >= argc) usage ();
  152.         name = argv[i];
  153.         continue;
  154.           case 'r':            /* -rv */
  155.         reverse = True;
  156.         continue;
  157.           case 's':            /* -s */
  158.         attr.save_under = True;
  159.         mask |= CWSaveUnder;
  160.         continue;
  161.           default:
  162.         usage ();
  163.         }                /* end switch on - */
  164.     } else 
  165.       usage ();
  166.     }                    /* end for over argc */
  167.  
  168.     dpy = XOpenDisplay (displayname);
  169.     if (!dpy) {
  170.     fprintf (stderr, "%s:  unable to open display '%s'\n",
  171.          ProgramName, XDisplayName (displayname));
  172.     exit (1);
  173.     }
  174.  
  175.     screen = DefaultScreen (dpy);
  176.  
  177.     /* select for all events */
  178.     attr.event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask |
  179.                ButtonReleaseMask | EnterWindowMask |
  180.                LeaveWindowMask | PointerMotionMask | 
  181.                Button1MotionMask |
  182.                Button2MotionMask | Button3MotionMask |
  183.                Button4MotionMask | Button5MotionMask |
  184.                ButtonMotionMask | KeymapStateMask |
  185.                ExposureMask | VisibilityChangeMask | 
  186.                StructureNotifyMask | /* ResizeRedirectMask | */
  187.                SubstructureNotifyMask | SubstructureRedirectMask |
  188.                FocusChangeMask | PropertyChangeMask |
  189.                ColormapChangeMask | OwnerGrabButtonMask;
  190.  
  191.     if (w) {
  192.     XGetWindowAttributes(dpy, w, &wattr);
  193.     if (wattr.all_event_masks & ButtonPressMask)
  194.         attr.event_mask &= ~ButtonPressMask;
  195.     attr.event_mask &= ~SubstructureRedirectMask;
  196.     XSelectInput(dpy, w, attr.event_mask);
  197.     } else {
  198.     set_sizehints (&hints, OUTER_WINDOW_MIN_WIDTH, OUTER_WINDOW_MIN_HEIGHT,
  199.                OUTER_WINDOW_DEF_WIDTH, OUTER_WINDOW_DEF_HEIGHT, 
  200.                OUTER_WINDOW_DEF_X, OUTER_WINDOW_DEF_Y, geom);
  201.  
  202.     if (reverse) {
  203.         back = BlackPixel(dpy,screen);
  204.         fore = WhitePixel(dpy,screen);
  205.     } else {
  206.         back = WhitePixel(dpy,screen);
  207.         fore = BlackPixel(dpy,screen);
  208.     }
  209.  
  210.     attr.background_pixel = back;
  211.     attr.border_pixel = fore;
  212.     mask |= (CWBackPixel | CWBorderPixel | CWEventMask);
  213.  
  214.     w = XCreateWindow (dpy, RootWindow (dpy, screen), hints.x, hints.y,
  215.                hints.width, hints.height, borderwidth, 0,
  216.                InputOutput, (Visual *)CopyFromParent,
  217.                mask, &attr);
  218.  
  219.     XSetStandardProperties (dpy, w, name, NULL, (Pixmap) 0,
  220.                 argv, argc, &hints);
  221.  
  222.     subw = XCreateSimpleWindow (dpy, w, INNER_WINDOW_X, INNER_WINDOW_Y,
  223.                     INNER_WINDOW_WIDTH, INNER_WINDOW_HEIGHT,
  224.                     INNER_WINDOW_BORDER,
  225.                     attr.border_pixel, attr.background_pixel);
  226.  
  227.     XMapWindow (dpy, subw);        /* map before w so that it appears */
  228.     XMapWindow (dpy, w);
  229.  
  230.     printf ("Outer window is 0x%lx, inner window is 0x%lx\n", w, subw);
  231.     }
  232.  
  233.     for (done = 0; !done; ) {
  234.     XEvent event;
  235.  
  236.     XNextEvent (dpy, &event);
  237.  
  238.     switch (event.type) {
  239.       case KeyPress:
  240.         prologue (&event, "KeyPress");
  241.         do_KeyPress (&event);
  242.         break;
  243.       case KeyRelease:
  244.         prologue (&event, "KeyRelease");
  245.         do_KeyRelease (&event);
  246.         break;
  247.       case ButtonPress:
  248.         prologue (&event, "ButtonPress");
  249.         do_ButtonPress (&event);
  250.         break;
  251.       case ButtonRelease:
  252.         prologue (&event, "ButtonRelease");
  253.         do_ButtonRelease (&event);
  254.         break;
  255.       case MotionNotify:
  256.         prologue (&event, "MotionNotify");
  257.         do_MotionNotify (&event);
  258.         break;
  259.       case EnterNotify:
  260.         prologue (&event, "EnterNotify");
  261.         do_EnterNotify (&event);
  262.         break;
  263.       case LeaveNotify:
  264.         prologue (&event, "LeaveNotify");
  265.         do_LeaveNotify (&event);
  266.         break;
  267.       case FocusIn:
  268.         prologue (&event, "FocusIn");
  269.         do_FocusIn (&event);
  270.         break;
  271.       case FocusOut:
  272.         prologue (&event, "FocusOut");
  273.         do_FocusOut (&event);
  274.         break;
  275.       case KeymapNotify:
  276.         prologue (&event, "KeymapNotify");
  277.         do_KeymapNotify (&event);
  278.         break;
  279.       case Expose:
  280.         prologue (&event, "Expose");
  281.         do_Expose (&event);
  282.         break;
  283.       case GraphicsExpose:
  284.         prologue (&event, "GraphicsExpose");
  285.         do_GraphicsExpose (&event);
  286.         break;
  287.       case NoExpose:
  288.         prologue (&event, "NoExpose");
  289.         do_NoExpose (&event);
  290.         break;
  291.       case VisibilityNotify:
  292.         prologue (&event, "VisibilityNotify");
  293.         do_VisibilityNotify (&event);
  294.         break;
  295.       case CreateNotify:
  296.         prologue (&event, "CreateNotify");
  297.         do_CreateNotify (&event);
  298.         break;
  299.       case DestroyNotify:
  300.         prologue (&event, "DestroyNotify");
  301.         do_DestroyNotify (&event);
  302.         break;
  303.       case UnmapNotify:
  304.         prologue (&event, "UnmapNotify");
  305.         do_UnmapNotify (&event);
  306.         break;
  307.       case MapNotify:
  308.         prologue (&event, "MapNotify");
  309.         do_MapNotify (&event);
  310.         break;
  311.       case MapRequest:
  312.         prologue (&event, "MapRequest");
  313.         do_MapRequest (&event);
  314.         break;
  315.       case ReparentNotify:
  316.         prologue (&event, "ReparentNotify");
  317.         do_ReparentNotify (&event);
  318.         break;
  319.       case ConfigureNotify:
  320.         prologue (&event, "ConfigureNotify");
  321.         do_ConfigureNotify (&event);
  322.         break;
  323.       case ConfigureRequest:
  324.         prologue (&event, "ConfigureRequest");
  325.         do_ConfigureRequest (&event);
  326.         break;
  327.       case GravityNotify:
  328.         prologue (&event, "GravityNotify");
  329.         do_GravityNotify (&event);
  330.         break;
  331.       case ResizeRequest:
  332.         prologue (&event, "ResizeRequest");
  333.         do_ResizeRequest (&event);
  334.         break;
  335.       case CirculateNotify:
  336.         prologue (&event, "CirculateNotify");
  337.         do_CirculateNotify (&event);
  338.         break;
  339.       case CirculateRequest:
  340.         prologue (&event, "CirculateRequest");
  341.         do_CirculateRequest (&event);
  342.         break;
  343.       case PropertyNotify:
  344.         prologue (&event, "PropertyNotify");
  345.         do_PropertyNotify (&event);
  346.         break;
  347.       case SelectionClear:
  348.         prologue (&event, "SelectionClear");
  349.         do_SelectionClear (&event);
  350.         break;
  351.       case SelectionRequest:
  352.         prologue (&event, "SelectionRequest");
  353.         do_SelectionRequest (&event);
  354.         break;
  355.       case SelectionNotify:
  356.         prologue (&event, "SelectionNotify");
  357.         do_SelectionNotify (&event);
  358.         break;
  359.       case ColormapNotify:
  360.         prologue (&event, "ColormapNotify");
  361.         do_ColormapNotify (&event);
  362.         break;
  363.       case ClientMessage:
  364.         prologue (&event, "ClientMessage");
  365.         do_ClientMessage (&event);
  366.         break;
  367.       case MappingNotify:
  368.         prologue (&event, "MappingNotify");
  369.         do_MappingNotify (&event);
  370.         break;
  371.       default:
  372.         printf ("Unknown event type %d\n", event.type);
  373.         break;
  374.     }
  375.     }
  376.  
  377.     XCloseDisplay (dpy);
  378.     exit (0);
  379. }
  380.  
  381. prologue (eventp, event_name)
  382.     XEvent *eventp;
  383.     char *event_name;
  384. {
  385.     XAnyEvent *e = (XAnyEvent *) eventp;
  386.  
  387.     printf ("\n%s event, serial %ld, synthetic %s, window 0x%lx,\n",
  388.         event_name, e->serial, e->send_event ? Yes : No, e->window);
  389.     return;
  390. }
  391.  
  392.  
  393. do_KeyPress (eventp)
  394.     XEvent *eventp;
  395. {
  396.     XKeyEvent *e = (XKeyEvent *) eventp;
  397.     KeySym ks;
  398.     char *ksname;
  399.     int nbytes;
  400.     char str[256+1];
  401.  
  402.     nbytes = XLookupString (e, str, 256, &ks, NULL);
  403.     if (ks == NoSymbol)
  404.     ksname = "NoSymbol";
  405.     else if (!(ksname = XKeysymToString (ks)))
  406.     ksname = "(no name)";
  407.     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
  408.         e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
  409.     printf ("    state 0x%x, keycode %u (keysym 0x%x, %s), same_screen %s,\n",
  410.         e->state, e->keycode, ks, ksname, e->same_screen ? Yes : No);
  411.     if (nbytes < 0) nbytes = 0;
  412.     if (nbytes > 256) nbytes = 256;
  413.     str[nbytes] = '\0';
  414.     printf ("    XLookupString gives %d characters:  \"%s\"\n", nbytes, str);
  415.  
  416.     return;
  417. }
  418.  
  419. do_KeyRelease (eventp)
  420.     XEvent *eventp;
  421. {
  422.     do_KeyPress (eventp);        /* since it has the same info */
  423.     return;
  424. }
  425.  
  426. do_ButtonPress (eventp)
  427.     XEvent *eventp;
  428. {
  429.     XButtonEvent *e = (XButtonEvent *) eventp;
  430.  
  431.     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
  432.         e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
  433.     printf ("    state 0x%x, button %u, same_screen %s\n",
  434.         e->state, e->button, e->same_screen ? Yes : No);
  435.  
  436.     return;
  437. }
  438.  
  439. do_ButtonRelease (eventp)
  440.     XEvent *eventp;
  441. {
  442.     do_ButtonPress (eventp);        /* since it has the same info */
  443.     return;
  444. }
  445.  
  446. do_MotionNotify (eventp)
  447.     XEvent *eventp;
  448. {
  449.     XMotionEvent *e = (XMotionEvent *) eventp;
  450.  
  451.     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
  452.         e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
  453.     printf ("    state 0x%x, is_hint %u, same_screen %s\n",
  454.         e->state, e->is_hint, e->same_screen ? Yes : No);
  455.  
  456.     return;
  457. }
  458.  
  459. do_EnterNotify (eventp)
  460.     XEvent *eventp;
  461. {
  462.     XCrossingEvent *e = (XCrossingEvent *) eventp;
  463.     char *mode, *detail;
  464.     char dmode[10], ddetail[10];
  465.  
  466.     switch (e->mode) {
  467.       case NotifyNormal:  mode = "NotifyNormal"; break;
  468.       case NotifyGrab:  mode = "NotifyGrab"; break;
  469.       case NotifyUngrab:  mode = "NotifyUngrab"; break;
  470.       case NotifyWhileGrabbed:  mode = "NotifyWhileGrabbed"; break;
  471.       default:  mode = dmode, sprintf (dmode, "%u", e->mode); break;
  472.     }
  473.  
  474.     switch (e->detail) {
  475.       case NotifyAncestor:  detail = "NotifyAncestor"; break;
  476.       case NotifyVirtual:  detail = "NotifyVirtual"; break;
  477.       case NotifyInferior:  detail = "NotifyInferior"; break;
  478.       case NotifyNonlinear:  detail = "NotifyNonlinear"; break;
  479.       case NotifyNonlinearVirtual:  detail = "NotifyNonlinearVirtual"; break;
  480.       case NotifyPointer:  detail = "NotifyPointer"; break;
  481.       case NotifyPointerRoot:  detail = "NotifyPointerRoot"; break;
  482.       case NotifyDetailNone:  detail = "NotifyDetailNone"; break;
  483.       default:  detail = ddetail; sprintf (ddetail, "%u", e->detail); break;
  484.     }
  485.  
  486.     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
  487.         e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
  488.     printf ("    mode %s, detail %s, same_screen %s,\n",
  489.         mode, detail, e->same_screen ? Yes : No);
  490.     printf ("    focus %s, state %u\n", e->focus ? Yes : No, e->state);
  491.  
  492.     return;
  493. }
  494.  
  495. do_LeaveNotify (eventp)
  496.     XEvent *eventp;
  497. {
  498.     do_EnterNotify (eventp);        /* since it has same information */
  499.     return;
  500. }
  501.  
  502. do_FocusIn (eventp)
  503.     XEvent *eventp;
  504. {
  505.     XFocusChangeEvent *e = (XFocusChangeEvent *) eventp;
  506.     char *mode, *detail;
  507.     char dmode[10], ddetail[10];
  508.  
  509.     switch (e->mode) {
  510.       case NotifyNormal:  mode = "NotifyNormal"; break;
  511.       case NotifyGrab:  mode = "NotifyGrab"; break;
  512.       case NotifyUngrab:  mode = "NotifyUngrab"; break;
  513.       case NotifyWhileGrabbed:  mode = "NotifyWhileGrabbed"; break;
  514.       default:  mode = dmode, sprintf (dmode, "%u", e->mode); break;
  515.     }
  516.  
  517.     switch (e->detail) {
  518.       case NotifyAncestor:  detail = "NotifyAncestor"; break;
  519.       case NotifyVirtual:  detail = "NotifyVirtual"; break;
  520.       case NotifyInferior:  detail = "NotifyInferior"; break;
  521.       case NotifyNonlinear:  detail = "NotifyNonlinear"; break;
  522.       case NotifyNonlinearVirtual:  detail = "NotifyNonlinearVirtual"; break;
  523.       case NotifyPointer:  detail = "NotifyPointer"; break;
  524.       case NotifyPointerRoot:  detail = "NotifyPointerRoot"; break;
  525.       case NotifyDetailNone:  detail = "NotifyDetailNone"; break;
  526.       default:  detail = ddetail; sprintf (ddetail, "%u", e->detail); break;
  527.     }
  528.  
  529.     printf ("    mode %s, detail %s\n", mode, detail);
  530.     return;
  531. }
  532.  
  533. do_FocusOut (eventp)
  534.     XEvent *eventp;
  535. {
  536.     do_FocusIn (eventp);        /* since it has same information */
  537.     return;
  538. }
  539.  
  540. do_KeymapNotify (eventp)
  541.     XEvent *eventp;
  542. {
  543.     XKeymapEvent *e = (XKeymapEvent *) eventp;
  544.     int i;
  545.  
  546.     printf ("    keys:  ");
  547.     for (i = 0; i < 32; i++) {
  548.     if (i == 16) printf ("\n           ");
  549.     printf ("%-3u ", (unsigned int) e->key_vector[i]);
  550.     }
  551.     printf ("\n");
  552.     return;
  553. }
  554.  
  555. do_Expose (eventp)
  556.     XEvent *eventp;
  557. {
  558.     XExposeEvent *e = (XExposeEvent *) eventp;
  559.  
  560.     printf ("    (%d,%d), width %d, height %d, count %d\n",
  561.         e->x, e->y, e->width, e->height, e->count);
  562.     return;
  563. }
  564.  
  565. do_GraphicsExpose (eventp)
  566.     XEvent *eventp;
  567. {
  568.     XGraphicsExposeEvent *e = (XGraphicsExposeEvent *) eventp;
  569.     char *m;
  570.     char mdummy[10];
  571.  
  572.     switch (e->major_code) {
  573.       case X_CopyArea:  m = "CopyArea";  break;
  574.       case X_CopyPlane:  m = "CopyPlane";  break;
  575.       default:  m = mdummy; sprintf (mdummy, "%d", e->major_code); break;
  576.     }
  577.  
  578.     printf ("    (%d,%d), width %d, height %d, count %d,\n",
  579.         e->x, e->y, e->width, e->height, e->count);
  580.     printf ("    major %s, minor %d\n", m, e->minor_code);
  581.     return;
  582. }
  583.  
  584. do_NoExpose (eventp)
  585.     XEvent *eventp;
  586. {
  587.     XNoExposeEvent *e = (XNoExposeEvent *) eventp;
  588.     char *m;
  589.     char mdummy[10];
  590.  
  591.     switch (e->major_code) {
  592.       case X_CopyArea:  m = "CopyArea";  break;
  593.       case X_CopyPlane:  m = "CopyPlane";  break;
  594.       default:  m = mdummy; sprintf (mdummy, "%d", e->major_code); break;
  595.     }
  596.  
  597.     printf ("    major %s, minor %d\n", m, e->minor_code);
  598.     return;
  599. }
  600.  
  601. do_VisibilityNotify (eventp)
  602.     XEvent *eventp;
  603. {
  604.     XVisibilityEvent *e = (XVisibilityEvent *) eventp;
  605.     char *v;
  606.     char vdummy[10];
  607.  
  608.     switch (e->state) {
  609.       case VisibilityUnobscured:  v = "VisibilityUnobscured"; break;
  610.       case VisibilityPartiallyObscured:  v = "VisibilityPartiallyObscured"; break;
  611.       case VisibilityFullyObscured:  v = "VisibilityFullyObscured"; break;
  612.       default:  v = vdummy; sprintf (vdummy, "%d", e->state); break;
  613.     }
  614.  
  615.     printf ("    state %s\n", v);
  616.     return;
  617. }
  618.  
  619. do_CreateNotify (eventp)
  620.     XEvent *eventp;
  621. {
  622.     XCreateWindowEvent *e = (XCreateWindowEvent *) eventp;
  623.  
  624.     printf ("    parent 0x%lx, window 0x%lx, (%d,%d), width %d, height %d\n",
  625.         e->parent, e->window, e->x, e->y, e->width, e->height);
  626.     printf ("border_width %d, override %s\n",
  627.         e->border_width, e->override_redirect ? Yes : No);
  628.     return;
  629. }
  630.  
  631. do_DestroyNotify (eventp)
  632.     XEvent *eventp;
  633. {
  634.     XDestroyWindowEvent *e = (XDestroyWindowEvent *) eventp;
  635.  
  636.     printf ("    event 0x%lx, window 0x%lx\n", e->event, e->window);
  637.     return;
  638. }
  639.  
  640. do_UnmapNotify (eventp)
  641.     XEvent *eventp;
  642. {
  643.     XUnmapEvent *e = (XUnmapEvent *) eventp;
  644.  
  645.     printf ("    event 0x%lx, window 0x%lx, from_configure %s\n",
  646.         e->event, e->window, e->from_configure ? Yes : No);
  647.     return;
  648. }
  649.  
  650. do_MapNotify (eventp)
  651.     XEvent *eventp;
  652. {
  653.     XMapEvent *e = (XMapEvent *) eventp;
  654.  
  655.     printf ("    event 0x%lx, window 0x%lx, override %s\n",
  656.         e->event, e->window, e->override_redirect ? Yes : No);
  657.     return;
  658. }
  659.  
  660. do_MapRequest (eventp)
  661.     XEvent *eventp;
  662. {
  663.     XMapRequestEvent *e = (XMapRequestEvent *) eventp;
  664.  
  665.     printf ("    parent 0x%lx, window 0x%lx\n", e->parent, e->window);
  666.     return;
  667. }
  668.  
  669. do_ReparentNotify (eventp)
  670.     XEvent *eventp;
  671. {
  672.     XReparentEvent *e = (XReparentEvent *) eventp;
  673.  
  674.     printf ("    event 0x%lx, window 0x%lx, parent 0x%lx,\n",
  675.         e->event, e->window, e->parent);
  676.     printf ("    (%d,%d), override %s\n", e->x, e->y, 
  677.         e->override_redirect ? Yes : No);
  678.     return;
  679. }
  680.  
  681. do_ConfigureNotify (eventp)
  682.     XEvent *eventp;
  683. {
  684.     XConfigureEvent *e = (XConfigureEvent *) eventp;
  685.  
  686.     printf ("    event 0x%lx, window 0x%lx, (%d,%d), width %d, height %d,\n",
  687.         e->event, e->window, e->x, e->y, e->width, e->height);
  688.     printf ("    border_width %d, above 0x%lx, override %s\n",
  689.         e->border_width, e->above, e->override_redirect ? Yes : No);
  690.     return;
  691. }
  692.  
  693. do_ConfigureRequest (eventp)
  694.     XEvent *eventp;
  695. {
  696.     XConfigureRequestEvent *e = (XConfigureRequestEvent *) eventp;
  697.     char *detail;
  698.     char ddummy[10];
  699.  
  700.     switch (e->detail) {
  701.       case Above:  detail = "Above";  break;
  702.       case Below:  detail = "Below";  break;
  703.       case TopIf:  detail = "TopIf";  break;
  704.       case BottomIf:  detail = "BottomIf"; break;
  705.       case Opposite:  detail = "Opposite"; break;
  706.       default:  detail = ddummy; sprintf (ddummy, "%d", e->detail); break;
  707.     }
  708.  
  709.     printf ("    parent 0x%lx, window 0x%lx, (%d,%d), width %d, height %d,\n",
  710.         e->parent, e->window, e->x, e->y, e->width, e->height);
  711.     printf ("    border_width %d, above 0x%lx, detail %s, value 0x%lx\n",
  712.         e->border_width, e->above, detail, e->value_mask);
  713.     return;
  714. }
  715.  
  716. do_GravityNotify (eventp)
  717.     XEvent *eventp;
  718. {
  719.     XGravityEvent *e = (XGravityEvent *) eventp;
  720.  
  721.     printf ("    event 0x%lx, window 0x%lx, (%d,%d)\n",
  722.         e->event, e->window, e->x, e->y);
  723.     return;
  724. }
  725.  
  726. do_ResizeRequest (eventp)
  727.     XEvent *eventp;
  728. {
  729.     XResizeRequestEvent *e = (XResizeRequestEvent *) eventp;
  730.  
  731.     printf ("    width %d, height %d\n", e->width, e->height);
  732.     return;
  733. }
  734.  
  735. do_CirculateNotify (eventp)
  736.     XEvent *eventp;
  737. {
  738.     XCirculateEvent *e = (XCirculateEvent *) eventp;
  739.     char *p;
  740.     char pdummy[10];
  741.  
  742.     switch (e->place) {
  743.       case PlaceOnTop:  p = "PlaceOnTop"; break;
  744.       case PlaceOnBottom:  p = "PlaceOnBottom"; break;
  745.       default:  p = pdummy; sprintf (pdummy, "%d", e->place); break;
  746.     }
  747.  
  748.     printf ("    event 0x%lx, window 0x%lx, place %s\n",
  749.         e->event, e->window, p);
  750.     return;
  751. }
  752.  
  753. do_CirculateRequest (eventp)
  754.     XEvent *eventp;
  755. {
  756.     XCirculateRequestEvent *e = (XCirculateRequestEvent *) eventp;
  757.     char *p;
  758.     char pdummy[10];
  759.  
  760.     switch (e->place) {
  761.       case PlaceOnTop:  p = "PlaceOnTop"; break;
  762.       case PlaceOnBottom:  p = "PlaceOnBottom"; break;
  763.       default:  p = pdummy; sprintf (pdummy, "%d", e->place); break;
  764.     }
  765.  
  766.     printf ("    parent 0x%lx, window 0x%lx, place %s\n",
  767.         e->parent, e->window, p);
  768.     return;
  769. }
  770.  
  771. do_PropertyNotify (eventp)
  772.     XEvent *eventp;
  773. {
  774.     XPropertyEvent *e = (XPropertyEvent *) eventp;
  775.     char *aname = XGetAtomName (dpy, e->atom);
  776.     char *s;
  777.     char sdummy[10];
  778.  
  779.     switch (e->state) {
  780.       case PropertyNewValue:  s = "PropertyNewValue"; break;
  781.       case PropertyDelete:  s = "PropertyDelete"; break;
  782.       default:  s = sdummy; sprintf (sdummy, "%d", e->state); break;
  783.     }
  784.  
  785.     printf ("    atom 0x%lx (%s), time %lu, state %s\n",
  786.        e->atom, aname ? aname : Unknown, e->time,  s);
  787.  
  788.     if (aname) XFree (aname);
  789.     return;
  790. }
  791.  
  792. do_SelectionClear (eventp)
  793.     XEvent *eventp;
  794. {
  795.     XSelectionClearEvent *e = (XSelectionClearEvent *) eventp;
  796.     char *sname = XGetAtomName (dpy, e->selection);
  797.  
  798.     printf ("    selection 0x%lx (%s), time %lu\n",
  799.         e->selection, sname ? sname : Unknown, e->time);
  800.  
  801.     if (sname) XFree (sname);
  802.     return;
  803. }
  804.  
  805. do_SelectionRequest (eventp)
  806.     XEvent *eventp;
  807. {
  808.     XSelectionRequestEvent *e = (XSelectionRequestEvent *) eventp;
  809.     char *sname = XGetAtomName (dpy, e->selection);
  810.     char *tname = XGetAtomName (dpy, e->target);
  811.     char *pname = XGetAtomName (dpy, e->property);
  812.  
  813.     printf ("    owner 0x%lx, requestor 0x%lx, selection 0x%lx (%s),\n",
  814.         e->owner, e->requestor, e->selection, sname ? sname : Unknown);
  815.     printf ("    target 0x%lx (%s), property 0x%lx (%s), time %lu\n",
  816.         e->target, tname ? tname : Unknown, e->property,
  817.         pname ? pname : Unknown, e->time);
  818.  
  819.     if (sname) XFree (sname);
  820.     if (tname) XFree (tname);
  821.     if (pname) XFree (pname);
  822.  
  823.     return;
  824. }
  825.  
  826. do_SelectionNotify (eventp)
  827.     XEvent *eventp;
  828. {
  829.     XSelectionEvent *e = (XSelectionEvent *) eventp;
  830.     char *sname = XGetAtomName (dpy, e->selection);
  831.     char *tname = XGetAtomName (dpy, e->target);
  832.     char *pname = XGetAtomName (dpy, e->property);
  833.  
  834.     printf ("    selection 0x%lx (%s), target 0x%lx (%s),\n",
  835.         e->selection, sname ? sname : Unknown, e->target,
  836.         tname ? tname : Unknown);
  837.     printf ("    property 0x%lx (%s), time %lu\n",
  838.         e->property, pname ? pname : Unknown, e->time);
  839.  
  840.     if (sname) XFree (sname);
  841.     if (tname) XFree (tname);
  842.     if (pname) XFree (pname);
  843.  
  844.     return;
  845. }
  846.  
  847. do_ColormapNotify (eventp)
  848.     XEvent *eventp;
  849. {
  850.     XColormapEvent *e = (XColormapEvent *) eventp;
  851.     char *s;
  852.     char sdummy[10];
  853.  
  854.     switch (e->state) {
  855.       case ColormapInstalled:  s = "ColormapInstalled"; break;
  856.       case ColormapUninstalled:  s = "ColormapUninstalled"; break;
  857.       default:  s = sdummy; sprintf (sdummy, "%d", e->state); break;
  858.     }
  859.  
  860.     printf ("    colormap 0x%lx, new %s, state %s\n",
  861.         e->colormap, e->new ? Yes : No, s);
  862.     return;
  863. }
  864.  
  865. do_ClientMessage (eventp)
  866.     XEvent *eventp;
  867. {
  868.     XClientMessageEvent *e = (XClientMessageEvent *) eventp;
  869.     char *mname = XGetAtomName (dpy, e->message_type);
  870.  
  871.     printf ("    message_type 0x%lx (%s), format %d\n",
  872.         e->message_type, mname ? mname : Unknown, e->format);
  873.  
  874.     if (mname) XFree (mname);
  875.     return;
  876. }
  877.  
  878. do_MappingNotify (eventp)
  879.     XEvent *eventp;
  880. {
  881.     XMappingEvent *e = (XMappingEvent *) eventp;
  882.     char *r;
  883.     char rdummy[10];
  884.  
  885.     switch (e->request) {
  886.       case MappingModifier:  r = "MappingModifier"; break;
  887.       case MappingKeyboard:  r = "MappingKeyboard"; break;
  888.       case MappingPointer:  r = "MappingPointer"; break;
  889.       default:  r = rdummy; sprintf (rdummy, "%d", e->request); break;
  890.     }
  891.  
  892.     printf ("    request %s, first_keycode %d, count %d\n",
  893.         r, e->first_keycode, e->count);
  894.     XRefreshKeyboardMapping(e);
  895.     return;
  896. }
  897.  
  898.  
  899.  
  900. set_sizehints (hintp, min_width, min_height,
  901.            defwidth, defheight, defx, defy, geom)
  902.     XSizeHints *hintp;
  903.     int min_width, min_height, defwidth, defheight, defx, defy;
  904.     char *geom;
  905. {
  906.     int geom_result;
  907.  
  908.     /* set the size hints, algorithm from xlib xbiff */
  909.  
  910.     hintp->width = hintp->min_width = min_width;
  911.     hintp->height = hintp->min_height = min_height;
  912.     hintp->flags = PMinSize;
  913.     hintp->x = hintp->y = 0;
  914.     geom_result = NoValue;
  915.     if (geom != NULL) {
  916.         geom_result = XParseGeometry (geom, &hintp->x, &hintp->y,
  917.                       (unsigned int *)&hintp->width,
  918.                       (unsigned int *)&hintp->height);
  919.     if ((geom_result & WidthValue) && (geom_result & HeightValue)) {
  920. #define max(a,b) ((a) > (b) ? (a) : (b))
  921.         hintp->width = max (hintp->width, hintp->min_width);
  922.         hintp->height = max (hintp->height, hintp->min_height);
  923.         hintp->flags |= USSize;
  924.     }
  925.     if ((geom_result & XValue) && (geom_result & YValue)) {
  926.         hintp->flags += USPosition;
  927.     }
  928.     }
  929.     if (!(hintp->flags & USSize)) {
  930.     hintp->width = defwidth;
  931.     hintp->height = defheight;
  932.     hintp->flags |= PSize;
  933.     }
  934. /*
  935.     if (!(hintp->flags & USPosition)) {
  936.     hintp->x = defx;
  937.     hintp->y = defy;
  938.     hintp->flags |= PPosition;
  939.     }
  940.  */
  941.     if (geom_result & XNegative) {
  942.     hintp->x = DisplayWidth (dpy, DefaultScreen (dpy)) + hintp->x -
  943.             hintp->width;
  944.     }
  945.     if (geom_result & YNegative) {
  946.     hintp->y = DisplayHeight (dpy, DefaultScreen (dpy)) + hintp->y -
  947.             hintp->height;
  948.     }
  949.     return;
  950. }
  951.  
  952.